﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace Teigha.Core
{
	public class OdGeMatrix2d : IDisposable
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdGeMatrix2d(IntPtr cPtr, bool cMemoryOwn)
		{
			this.swigCMemOwn = cMemoryOwn;
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdGeMatrix2d obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdGeMatrix2d()
		{
			this.Dispose();
		}

		public virtual void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							GlobalsPINVOKE.delete_OdGeMatrix2d(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
		}

		public OdGeMatrix2d() : this(GlobalsPINVOKE.new_OdGeMatrix2d(), MemoryManager.GetMemoryManager().GetCurrentTransaction() == null)
		{
			MemoryTransaction currentTransaction = MemoryManager.GetMemoryManager().GetCurrentTransaction();
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdGeMatrix2d(this.swigCPtr.Handle, true));
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double this[int row, int column]
		{
			get
			{
				return this.GetItem(row, column);
			}
			set
			{
				GlobalsPINVOKE.OdGeMatrix2d_entry_set(this.swigCPtr, row, column, value);
			}
		}

		public static OdGeMatrix2d operator *(OdGeMatrix2d m, OdGeMatrix2d d)
		{
			return m.Mul(d);
		}

		public static OdGePoint2d operator *(OdGeMatrix2d matrix, OdGePoint2d point)
		{
			return Globals.Mul(matrix, point);
		}

		public static OdGeVector2d operator *(OdGeMatrix2d matrix, OdGeVector2d vect)
		{
			return Globals.Mul(matrix, vect);
		}

		public static OdGeMatrix2d kIdentity
		{
			get
			{
				IntPtr intPtr = GlobalsPINVOKE.OdGeMatrix2d_kIdentity_get();
				OdGeMatrix2d result = (intPtr == IntPtr.Zero) ? null : new OdGeMatrix2d(intPtr, false);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
				return result;
			}
		}

		public OdGeMatrix2d setToIdentity()
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToIdentity(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d Mul(OdGeMatrix2d matrix)
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_Mul__SWIG_0(this.swigCPtr, OdGeMatrix2d.getCPtr(matrix)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeMatrix2d preMultBy(OdGeMatrix2d leftSide)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_preMultBy(this.swigCPtr, OdGeMatrix2d.getCPtr(leftSide));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d postMultBy(OdGeMatrix2d rightSide)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_postMultBy(this.swigCPtr, OdGeMatrix2d.getCPtr(rightSide));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d setToProduct(OdGeMatrix2d matrix1, OdGeMatrix2d matrix2)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToProduct(this.swigCPtr, OdGeMatrix2d.getCPtr(matrix1), OdGeMatrix2d.getCPtr(matrix2));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d invert()
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_invert(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d inverse()
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_inverse(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isSingular(OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_isSingular__SWIG_0(this.swigCPtr, OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isSingular()
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_isSingular__SWIG_1(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeMatrix2d transposeIt()
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_transposeIt(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d transpose()
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_transpose(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool IsEqual(OdGeMatrix2d matrix)
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_IsEqual(this.swigCPtr, OdGeMatrix2d.getCPtr(matrix));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool IsNotEqual(OdGeMatrix2d matrix)
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_IsNotEqual(this.swigCPtr, OdGeMatrix2d.getCPtr(matrix));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isEqualTo(OdGeMatrix2d matrix, OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_isEqualTo__SWIG_0(this.swigCPtr, OdGeMatrix2d.getCPtr(matrix), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isEqualTo(OdGeMatrix2d matrix)
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_isEqualTo__SWIG_1(this.swigCPtr, OdGeMatrix2d.getCPtr(matrix));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isUniScaledOrtho(OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_isUniScaledOrtho__SWIG_0(this.swigCPtr, OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isUniScaledOrtho()
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_isUniScaledOrtho__SWIG_1(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isScaledOrtho(OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_isScaledOrtho__SWIG_0(this.swigCPtr, OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isScaledOrtho()
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_isScaledOrtho__SWIG_1(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double scale()
		{
			double result = GlobalsPINVOKE.OdGeMatrix2d_scale(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double det()
		{
			double result = GlobalsPINVOKE.OdGeMatrix2d_det(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeMatrix2d setTranslation(OdGeVector2d vect)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setTranslation(this.swigCPtr, OdGeVector2d.getCPtr(vect).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeVector2d translation()
		{
			OdGeVector2d result = new OdGeVector2d(GlobalsPINVOKE.OdGeMatrix2d_translation__SWIG_0(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeMatrix2d translation(OdGeVector2d vector)
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_translation__SWIG_1(OdGeVector2d.getCPtr(vector).Handle), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isConformal(out double scale, out double angle, out bool isMirror, OdGeVector2d reflex)
		{
			bool result = GlobalsPINVOKE.OdGeMatrix2d_isConformal(this.swigCPtr, out scale, out angle, out isMirror, OdGeVector2d.getCPtr(reflex).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeMatrix2d setCoordSystem(OdGePoint2d origin, OdGeVector2d xAxis, OdGeVector2d yAxis)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setCoordSystem(this.swigCPtr, OdGePoint2d.getCPtr(origin), OdGeVector2d.getCPtr(xAxis).Handle, OdGeVector2d.getCPtr(yAxis).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public void getCoordSystem(OdGePoint2d origin, OdGeVector2d xAxis, OdGeVector2d yAxis)
		{
			GlobalsPINVOKE.OdGeMatrix2d_getCoordSystem(this.swigCPtr, OdGePoint2d.getCPtr(origin), OdGeVector2d.getCPtr(xAxis).Handle, OdGeVector2d.getCPtr(yAxis).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeMatrix2d setToTranslation(OdGeVector2d vect)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToTranslation(this.swigCPtr, OdGeVector2d.getCPtr(vect).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d setToRotation(double angle, OdGePoint2d center)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToRotation__SWIG_0(this.swigCPtr, angle, OdGePoint2d.getCPtr(center));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d setToRotation(double angle)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToRotation__SWIG_1(this.swigCPtr, angle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d setToScaling(double scale, OdGePoint2d center)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToScaling__SWIG_0(this.swigCPtr, scale, OdGePoint2d.getCPtr(center));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d setToScaling(double scale)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToScaling__SWIG_1(this.swigCPtr, scale);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d setToMirroring(OdGePoint2d mirrorPoint)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToMirroring__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(mirrorPoint));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d setToMirroring(OdGeLine2d mirrorLine)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToMirroring__SWIG_1(this.swigCPtr, OdGeLine2d.getCPtr(mirrorLine));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public OdGeMatrix2d setToAlignCoordSys(OdGePoint2d fromOrigin, OdGeVector2d fromXAxis, OdGeVector2d fromYAxis, OdGePoint2d toOrigin, OdGeVector2d toXAxis, OdGeVector2d toYAxis)
		{
			OdGeMatrix2d odGeMatrix2d = new OdGeMatrix2d();
			GlobalsPINVOKE.OdGeMatrix2d_setToAlignCoordSys(this.swigCPtr, OdGePoint2d.getCPtr(fromOrigin), OdGeVector2d.getCPtr(fromXAxis).Handle, OdGeVector2d.getCPtr(fromYAxis).Handle, OdGePoint2d.getCPtr(toOrigin), OdGeVector2d.getCPtr(toXAxis).Handle, OdGeVector2d.getCPtr(toYAxis).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					odGeMatrix2d[i, j] = this[i, j];
				}
			}
			return odGeMatrix2d;
		}

		public static OdGeMatrix2d rotation(double angle, OdGePoint2d center)
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_rotation__SWIG_0(angle, OdGePoint2d.getCPtr(center)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeMatrix2d rotation(double angle)
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_rotation__SWIG_1(angle), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeMatrix2d scaling(double scale, OdGePoint2d center)
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_scaling__SWIG_0(scale, OdGePoint2d.getCPtr(center)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeMatrix2d scaling(double scale)
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_scaling__SWIG_1(scale), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeMatrix2d mirroring(OdGePoint2d mirrorPoint)
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_mirroring__SWIG_0(OdGePoint2d.getCPtr(mirrorPoint)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeMatrix2d mirroring(OdGeLine2d mirrorLine)
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_mirroring__SWIG_1(OdGeLine2d.getCPtr(mirrorLine)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGeMatrix2d alignCoordSys(OdGePoint2d fromOrigin, OdGeVector2d fromXAxis, OdGeVector2d fromYAxis, OdGePoint2d toOrigin, OdGeVector2d toXAxis, OdGeVector2d toYAxis)
		{
			OdGeMatrix2d result = new OdGeMatrix2d(GlobalsPINVOKE.OdGeMatrix2d_alignCoordSys(OdGePoint2d.getCPtr(fromOrigin), OdGeVector2d.getCPtr(fromXAxis).Handle, OdGeVector2d.getCPtr(fromYAxis).Handle, OdGePoint2d.getCPtr(toOrigin), OdGeVector2d.getCPtr(toXAxis).Handle, OdGeVector2d.getCPtr(toYAxis).Handle), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double GetItem(int row, int column)
		{
			double result = GlobalsPINVOKE.OdGeMatrix2d_GetItem(this.swigCPtr, row, column);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private object locker = new object();

		private HandleRef swigCPtr;

		protected bool swigCMemOwn;
	}
}
